---
hide_table_of_contents: true
sidebar_label: Chains
sidebar_position: 3
---

import DocCardList from "@theme/DocCardList";
import CodeBlock from "@theme/CodeBlock";

# Chains

:::info
[Conceptual Guide](../../concepts/) • [How-to Guides](../../how-to/)
:::

Chains enable you to combine language models with other sources of information, third-party APIs, or even other language models. This allows you to create powerful, multi-step applications that go beyond single LLM calls.

LangChainGo provides a standard interface for chains, along with several built-in implementations for common patterns. You can also create custom chains by implementing the `Chain` interface.

## Key Concepts

- **Sequential Processing**: Chains execute steps in sequence, passing outputs between stages
- **Flexible Input/Output**: Chains work with map-based inputs and outputs for maximum flexibility  
- **Memory Integration**: Chains can maintain conversation state across calls
- **Composability**: Chains can be combined to create complex workflows

## Built-in Chain Types

### LLM Chain
The simplest chain that calls an LLM with a prompt template.

### Sequential Chain
Chains multiple steps together, where each step's output feeds into the next.

### Map-Reduce Chain
Processes large documents by mapping operations across chunks and reducing results.

### Conversation Chain
Maintains conversation memory while processing new inputs.

### Retrieval QA Chain
Combines document retrieval with question answering capabilities.

## Executing chains

In LangChain there are multiple functions ment to execute chains.

### Call
Call is the standard function used for executing an chain. The function takes a context, the chain to be executed and the input values of the chain. The input values is a map with string keys and any value. The function returns the output values of the chain and a potential error.

```go
res, err := chains.Call(
  context.Background(),
  chain,
  map[string]any{
    "product": "colorful socks",
  },
)
if err != nil {
  log.Fatal(err)
}
fmt.Println(res)
```

```
map[text:

Socktastic!]
```

### Run
If a chain only expects one input and returns a string the run function can be used to execute the chain. The privious example could therefore be written like this:

```go
text, err := chains.Run(
    context.Background(),
    chain,
    "colorful socks",
)
if err != nil {
  log.Fatal(err)
}
fmt.Println(text)
```

```
Socktastic!
```

### Predict
Many chains expect multiple input values and returns one string. For these cases the predict function is handy.

```go
text, err := chains.Predict(
    context.Background(),
    chain,
    map[string]any{
      "product": "colorful socks",
      "description": "The company is based in California"
    }
)
if err != nil {
  log.Fatal(err)
}
fmt.Println(text)
```

## Advanced

To implement your own custom chain you must create an struct that implements the chain interface. 

```go
// Chain is the interface all chains must implement.
type Chain interface {
  // Call runs the logic of the chain and returns the output. This method should
	// not be called directly. Use rather the Call, Run or Predict functions that
	// handles the memory and other aspects of the chain.
	Call(ctx context.Context, inputs map[string]any, options ...ChainCallOption) (map[string]any, error)
	// GetMemory gets the memory of the chain.
	GetMemory() schema.Memory
	// InputKeys returns the input keys the chain expects.
	GetInputKeys() []string
	// OutputKeys returns the output keys the chain expects.
	GetOutputKeys() []string
}
```

<DocCardList />
